babl-palette: fix default palette double-data size

babl: fix trc registrationof ACES spaces

babl: predefine ACEScg and ACES2065-1 BablSpaces

tests: add format_with_space test

Testing that both R'G'B' formats and CIE Lab float keep the space they have
been created with.

babl: refactor format registration to loop over types

Also register full set of R~G~B~ and Y~ formats for all the types.

babl: add ~ variants to gray color models

We do not add premultiplied sRGB trc variants even if this exists for RGB
since it is the type of premultiplied alpha cairo expects. The less code
that does non-linear compositing the better, excluding some possibilities
also reduces the combinatorial overhead of finding conversion paths in babl.

babl: add R~G~B~ color models and pixel formats

From a given BablSpace which defines RGB chromaticities and
per component TRCs, the following are the defined formats:

R'G'B' with the TRCs applied
RGB    linear data

and now a new one

R~G~B~ with the sRGB TRC, this permits any BablSpace to be the
native format of a buffer in an application while having both
a 'perceptual' in R~G~B~ and linear in RGB that is possible
to derive from it. Importantly it is also possible to recover
the babl space used to create the buffer.

babl: clarify internal gray babl-id enums

Use GRAY_LINEAR and GRAY_NONLINEAR making the introduction of PERCEPTUAL
easier.

babl: remove outdated comment

babl: rename functions that used to refer to specific gamma

The definitions of components and formats for linear and nonlinear formats in
model-rgb and model-gray are now using the TRC of a BablSpace, thus in the
format syntax ' now means nonlinear, not sRGB / 2.2 gamma - even though it ends
up meaning that for formats create without specifying the space.

babl-palette: warn when trying to create a palette with > 256 colors

... and only use the first 256 colors.

babl-fish: fix concurrent babl_fish()/process() calls with palette formats

In babl_fish(), don't call _babl_fish_rig_dispatch() on existing
path fishes during each lookup.  We already call this function on
all path fishes upon creation (in particular, after commit
b34a9672c8c9a42923a8f0b2650af30b1efe635c), so this isn't necessary.

This fixes an issue where the _babl_fish_rig_dispatch() call in
babl_fish() would temporarily modify the value of babl->fish.data,
causing a concurrent babl_process[_rows]() call in another thread
to pass the wrong 'data' value down to the conversion function.  In
particular, this could cause palette conversions to segfault.

babl: fix fixed to double conversions

See issue #18 https://gitlab.gnome.org/GNOME/babl/issues/18

babl-space: babl_space_new_from_chromaticities add equalize_matrix argument

Part of the problem in issue #18

This API is internal only for now so we can change it, changing to use a
hard-coded pre-quantized chromaticities set for the internal sRGB space.

This preserve the gray axis matrix equalization performed for other spaces used
with babl, ideally we can improve the gray-axis equalization to match and
return to using it also for sRGB.

babl-palette: warn when trying to create a 0-color palette

In babl_palette_set_palette(), fall back to the default palette,
and log a warning, when trying to create a palette with < 1 colors.

babl-memory: allow babl_malloc(0) to succeed

Allow a babl_malloc() call with size == 0 to succeed, returning a
dummy allocation, instead of asserting on this condition.  The new
babl-palette code tries to allocate an empty buffer for the radii
array when creating a single-color palette, which would previously
lead to a crash.

babl-palette: fix default-palette radii array size

babl-palette: make default palette initialization thread-safe

... and allocate its radii statically.

post release version bump

release 0.1.50

Fix an unimportant typo

What's in a name? S.E.P.

tests: fix palette-concurrency-stress-test

Fix palette-concurrency-stress-test to accommodate the change to a
gamma-corrected 8-bit format (commit
fabcc6729ed453fb5c5affc565d0e837a78afc5c), and to little-endian
hash indices (commit 55ca45c8233af138d3fd388587b203d802b8396c).

The test should pass regardless, it simply didn't actually test for
the intended issue previously.

tools: code around gcc warning about 0 length format string

Meson build: fixes for windows build

Meson build: generate png image files for docs

Meson build: Improve git-version.h generation

Meson build: Tidy up code and improve readability

Meson build: improve doc generation

Meson build: Improve host environment detection / handling

Meson build: Improve SIMD assembly checking/use

babl-palette: initialize radii of default palette

... to prevent a segfault when using the default palette, namely,
in tests/palette.

babl-palette: speed up closest-color search

When constructing a palette format, calculate the distance between
each pair of colors in the palette, and for each color, construct a
list of all other colors and their distances from it, sorted by
distance.  When searching for the closest palette color to a given
input pixel, based on the assumption that nearby pixels have
similar color, use the color list of the previous pixel's best
match, and use the triangle inequality to stop the search early.

See the code comments for more details.

babl: use hashtable approach in double reference

Strictly speaking we should be doing the reference using
conversions to R'G'B'A double and using the distance metric
there; possibly getting a slight difference in result at
comparison ties.

In use GEGL ends up using both the really fast 8bit code paths
and the quite fast floating point code paths that use 8bit
hashtables for the lookup of conversion.

Progress on bug #787237 missing fast-paths.

babl-palette: fix regression in prefvious commit

The 255.5 factor for storing a double represenation is neccesary for
desired behavior.

babl-palette: improvements toward palette accuracy

For working at acceptable performance with large indexed images, it is
recommended to run with BABL_TOLERANCE=0.0385 or highger set in the environment
when launching GIMP, this permits using a hashtable based optimization that
still isn't accurate enough according to babl-expectations.

Part of progress on bug 787237

meson.build: synchronise with autotools version

WARNING: distributions should still not use meson to build packages - since
the meson build end up containing all instructions available on build host.

meson.build: Bump version to 0.1.48

Signed-off-by: Jan Vesely <jano.vesely@gmail.com>

babl: preliminary work to add float fast path to palette formats

Still not accurate enough to be acceptable, gets accepted by system with
a BABL_TOLERANCe of 0.045 or higher. Needs more work.

post release version bump

release 0.1.48

configure: try to add -Ofast to CFLAGS

CIE: Style fix

Fallout from 3788e861e545d43d5911677250c0f55d5f7ccedf

CIE: Add an SSE2 version of "RGBA float" to "CIE L float"

On an Intel i7 Haswell, it now takes 0.056s to convert a 15 megapixel
buffer from "RGBA float" to "CIE L float" instead of the earlier
0.107s.

https://bugzilla.gnome.org/show_bug.cgi?id=795686

CIE: Add an SSE2 version of "RGBA float" to "CIE Lab alpha float"

On an Intel i7 Haswell, it now takes 0.13s to convert a 15 megapixel
buffer from "RGBA float" to "CIE Lab alpha float" instead of the
earlier 0.27s.

SSEx doesn't have integer multiplication or division operations, and
using bit shifts to implement integer divisions by powers of 2 seems to
introduce errors. Therefore, it was problematic to use the cube root
approximation from Hacker's Delight, which uses quite a few integer
divisions to make the initial guess. Instead, Halley's method of
approximating the cube root seems more SSEx friendly because the
initial guess requires only one integer division, which we can manage
by jumping through a relatively small number of hoops.

The scalar version of Halley's method seems to have originated from
http://metamerist.com/cbrt/cbrt.htm but that's not accessible anymore.
At present there's a copy in CubeRoot.cpp in the Skia sources that's
licensed under a BSD-style license. There's some discussion on the
implementation at http://www.voidcn.com/article/p-gpwztojr-wt.html.

Note that Darktable also has an SSE2 version of the same algorithm,
but uses only a single iteration of Halley's method, which is too
coarse.

Here's some more discussion on the cube root approximation algorithms:
https://bugzilla.gnome.org/show_bug.cgi?id=791837

https://bugzilla.gnome.org/show_bug.cgi?id=795686

build: Add scaffolding for SSE3

It's currently unused, but is useful to have it around when comparing
different vectorization strategies.

https://bugzilla.gnome.org/show_bug.cgi?id=795686

CIE: Make the XYZ to LAB code look similar to the RGB to LAB code

Such superficial differences make the code harder to scan when looking
for bugs and optimization opportunities.

babl-internal: print debug output to stderr

extensions/two-table: remove unused variable

type-u8: fix u8 <> double conversions for chroma type

postrelease version bump

release 0.1.46

NEWS: update

tools: add html variant of path matrix

docs: remove short-cut coverage, which is too expensive to generate

extensions: remove many inline statements

When the functions are not reused by other fast path definitions, they are only
ever used as function pointers and inline is not neccesary.

extensions/double: adds some more paths

extensions: rename some extensions

extensions: add more u32 short cut utility conversions

extensions: u32<->float conversions in simple extension

They were using 'float' rather than 'double' data types for intermediate values
the lack of precision made the conversions be discarded by babl.

extensions: add missing 32bit.c

extensions: add some u32 fast paths

float-half: half fast paths for premultiplied alpha

extensions: add a double extension

This will permit slightly faster than the generic fast paths for some possibly
desired intermediate conversions. This also adds alpha stripping - which fills
in the last babl fast path currently reported missing on every launch of GIMP.

extensions: simplify gggl/conv_rgbF_rgbaF slightly

extensions/cairo: optimize R'G'B'A u8 to cairo-ARGB32

A combination of SIMD paths via float was beating the naive implementation in
the cairo extension, now the cairo extension comes out on top again.

extension: add some Y' u8 fast paths

GIMP makes use of "Y' u8" to "R'G'B' u8" and we had no paths covering it,
making it go through floating point. This commit adds code paths for expanding
single grayscale u8 to R'G'B and R'G'B'A as well as R'aG'aB'aA u8.

extensions/gegl-fixups: swap increments of src and dst in rgba8_rgb8

They were reversed, causing memory corruptions fixing bugs 794973 and 794972.

extensions: add rgba8_rgb8 conversion that copies 24/32bit chunks

Slightly speeding up RGB u8 (without alpha) painting in GIMP, the rgba to rgb
and reverse conversions are used together with the very fast SIMD conversions
that operate on chunks of 4 components.

post release version bump

release 0.1.44

babl: fix minor leak reported in bug #790924

Added mingw template pkgbuild.

Fix windows dirs_sep. Cleanup.

Remove check for linux header on win32

Remove os_win32

Temporarily disable checking for headers

PKGBUILD points again to gnome upstream

Fix : libdir for autotools and meson are not the same…

babl: fix icc matrix profile fast paths

For core members, babl relies on shared data layout between fish and
conversion to be able to do dispatch, and have source/target match -
though only for simple fishes.

The ICC fast path conversions also used the user data - but directly
instead of throug the argument, changing this makes the matrix and
luts work again - and let the conversions be used.

meson: Add missing single quote

Fixes build since ad0eac19c7a1f0046979ad8923f6ac1b7c2d7696 ("release 0.1.42")

Signed-off-by: Jan Vesely <jano.vesely@gmail.com>

post release version bump

release 0.1.42

babl: initialize the bpp of fishes loaded from cache

The cache loading code manually constructs path fishes, which did not
get their bpp initialized, this resulted in conversions of long runs to
fail, not crash - but stop processing after MAX_BUFFER_SIZE pixels.

post release version bump

NEWS: update

release 0.1.40

babl: add a test iteration multiplier

On my system many of the conversions got measured to costs of 3 4 and 5, these
makes a big room for measurement errors, to increase reliability the tests are
now run 4 times - making it a ranking of contenders with fewer collisions.

This will slightly increase incurred delayed on search for conversions.

babl: make pixel-count instrumentation opt-in

Checking if an integer is 0/1 is lower overhead than incrementing a long stored
kt a memory location. As a side effect, the entries in
~/.cache/babl/babl-fishes will not be sorted by most used to least used unless
the BABL_INSTRUMENT environment variable is set to a value.

babl: set user_data ptr for quick dispatch of 1 step path

babl: indentation and code cleanup

babl: use memcpy dpsatch path for all identity transforms

babl: reduce amount of instrumentation

The integer counter for number of processings overflows in some scenarios, thus
cannot be relied on for more than being informative.

We might ultimately want to also drop the instrumentation.

babl: store pointer to where user data resides instead of copy

This will make the scenario of changing user data work, we do it
unconditionally to avoid introducing a branch.

babl: refactor code to get rid of more branches in babl_process

In the best case scenario now, babl_process increments instrumentation
counters and directly calls the relevant registered fast path function,
with no additional call stack frames in-between.

babl: use babl_conversion_process where appropriate

Instead of overloading babl_process() with two tasks, both fishes and
conversions, use the conversion specific API for conversions directly.

babl: simplify branching in babl_process dispatch

babl: factor out some branches from path fish dispatch

babl: refactor conversion dispatch to do less branches at runtime

babl.map: update symbols for meson build

babl: add babl_process_rows api

Useful when fetching buffers smaller than a tile or partial tiles in APIs like
gegl_buffer_get.